package com.vizhuo.utils;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 字符串工具类
 * 
 * @author 刘大年
 * 
 */
public class StringUtil extends StringUtils {
    private static Logger log = LoggerFactory.getLogger(StringUtil.class);

    /**
     * 去除包名，传入com.abc.aaa返回aaa
     * 
     * @param str
     * @return
     */
    public static String removePackageName(String str) {
        if (isEmpty(str)) {
            return "";
        } else if (str.indexOf(".") == -1) {
            return str;
        } else {
            return str.substring(str.lastIndexOf(".") + 1, str.length());
        }
    }

    /**
     * 将字符串的首字母转换为大写
     * 
     * @param str
     * @return
     */
    public static String head2Upper(String str) {
        if (str == null) {
            return null;
        } else if ("".equals(str.trim())) {
            return "";
        } else {
            return str.substring(0, 1).toUpperCase() + str.substring(1);
        }
    }

    /**
     * 截取指定位数的字符串，并在截取后填充其他字符 如：输入12345678返回1234...
     * 
     * @param str
     *            要截取的字符串
     * @param len
     *            截取长度
     * @param tail
     *            末尾填充字符串
     * @return
     */
    public static String subStr(String str, int len, String tail) {
        if (str == null) {
            return "";
        } else if (str.length() <= len) {
            return str;
        } else {
            str = str.substring(0, len - 1);
            if (tail != null)
                str += tail;
            return str;
        }
    }

    /**
     * 按字节数截取指定位数的字符串，并在截取后填充其他字符 如：输入12345678返回1234...
     * 
     * @param str
     *            要截取的字符串
     * @param len
     *            截取长度（字节长度）
     * @param tail
     *            末尾填充字符串
     * @return
     */
    public static String subStrByBytes(String str, int len, String tail) {
        if (str == null) {
            return "";
        } else if (str.getBytes().length <= len) {
            return str.trim();
        } else {
            str = str.trim();
            String s = "";
            char[] c = str.toCharArray();
            int i = 0;
            if (tail != null) {
                len -= tail.getBytes().length;
            }
            while (s.getBytes().length < len) {
                s += String.valueOf(c[i]);
                i++;
            }
            if (s.getBytes().length > len) {
                s = s.substring(0, s.length() - 1);
            }
            if (tail != null)
                s += tail;
            return s;
        }
    }

    /**
     * 将普通字符串转换为html字符串
     * 
     * @param str
     * @return
     */
    public static String toHtml(String str) {
        if (str == null) {
            return "";
        } else {
            str = str.replaceAll("<", "&lt;");
            str = str.replaceAll(">", "&gt;");
            // str=str.replaceAll("'", "''");
            str = str.replaceAll(" ", "&nbsp;");
            str = str.replaceAll("\n", "<br>");
        }
        return str;
    }

    /**
     * 将html字符串转换为普通字符串
     * 
     * @param str
     * @return
     */
    public static String toText(String str) {
        if (str == null) {
            return "";
        } else {
            str = str.replaceAll("&lt;", "<");
            str = str.replaceAll("&gt;", ">");
            // str=str.replaceAll("''", "'");
            str = str.replaceAll("&nbsp;", " ");
            str = str.replaceAll("<br>", "\n");
        }
        return str;
    }

    /**
     * 去除字符串中的html标签，并返回指定长度的字符串
     * 
     * @param inputStr
     * @param len
     * @return
     */
    public static String htmlTagFilter(String inputStr, int len) {
        if (inputStr == null || "".equals(inputStr.trim())) {
            return "";
        }
        String outStr = inputStr.replaceAll("\\&[a-zA-Z]{1,10};", "") // 去除类似&lt;
                                                                      // &gt;
                                                                      // &nbsp;的字串
                .replaceAll("<[a-zA-Z]+[1-9]?[^><]*>", "") // 去除开始标签及没有结束标签的标签
                .replaceAll("</[a-zA-Z]+[1-9]?>", ""); // 去除结束标签
        if (outStr.length() > len) {
            outStr = outStr.substring(0, len);
            outStr += "...";
        }
        return outStr;
    }

    /**
     * 从左侧填充指定位数的指定字符 如：输入"1",4,'0'返回0001
     * 
     * @param src
     * @param len
     * @param fill
     * @return
     */
    public static String leftFill(String src, int len, char fill) {
        if (src == null) {
            return null;
        } else if (src.length() >= len) {
            return src;
        } else {
            while (src.length() < len) {
                src = fill + src;
            }
            return src;
        }
    }

    /**
     * 从右侧填充指定位数的指定字符 如：输入"1",4,'0'返回1000
     * 
     * @param src
     * @param len
     * @param fill
     * @return
     */
    public static String rightFill(String src, int len, char fill) {
        if (src == null) {
            return null;
        } else if (src.length() >= len) {
            return src;
        } else {
            while (src.length() < len) {
                src += fill;
            }
            return src;
        }
    }

    /**
     * 如果字符串为null则返回“”，否则返回其本身
     * 
     * @param str
     * @return
     */
    public static String null2empty(String str) {
        if (str == null) {
            return "";
        } else {
            return str;
        }
    }

    /**
     * 将回车进行转义替换成conStr中所包含的字符串
     * 
     * @param str
     *            要进行替换的字符串
     * @param conStr
     *            将回车替换成的目标字符串
     * @return
     */
    public static String enterConvert(String str, String conStr) {
        String[] tmp = str.split("\n");
        if (tmp != null && tmp.length > 0) {
            str = "";
            for (int i = 0; i < tmp.length; i++) {
                str += tmp[i].trim() + conStr;
            }

            str = str.substring(0, str.length() - conStr.length());
        }

        return str;
    }

    /**
     * 判断字符串str是否以prefix开头 如果是，直接返回str 否则，返回prefix + str
     * 
     * @param str
     * @param prefix
     * @return
     */
    public static String addPrefixIFNoHave(String str, String prefix) {
        if (isEmpty(str)) {
            return "";
        } else {
            if (str.startsWith(prefix)) {
                return str;
            } else {
                return prefix + str;
            }
        }
    }

    /**
     * 去除文件名的后缀名
     * 
     * @param fileName
     * @return
     */
    public static String removeFileTail(String fileName) {
        if (isEmpty(fileName)) {
            return fileName;
        } else if (fileName.indexOf(".") == -1) {
            return fileName;
        } else {
            fileName = fileName.substring(0, fileName.lastIndexOf("."));
            return fileName;
        }
    }

    /**
     * 判断两个字符串的前n位是否相同
     * 
     * @param str1
     * @param str2
     * @param n
     * @return
     */
    public static boolean startEQ(String str1, String str2, int n) {
        if (isEmpty(str1) || isEmpty(str2) || n < 1) {
            return false;
        }
        // 如果n的值大于两个字符串的长度，取最短的
        if (n > str1.length()) {
            n = str1.length();
        }
        if (n > str2.length()) {
            n = str2.length();
        }
        // 截取str1
        String tmp = str1.substring(0, n);
        // 用截取的字符串对比str2
        if (str2.startsWith(tmp)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 将字符串转为数字，做完加法后再返回以字符串类型返回
     * 
     * @param str
     *            字符串
     * @param num
     *            要增加的数值
     * @param lengthEQ
     *            加法后是否判断长度变化
     * @return
     * @throws Exception
     */
    public static String additionInt(String str, int num, boolean lengthEQ) throws Exception {
        // 如果字符串为空，返回其本身
        if (isEmpty(str)) {
            return str;
        }

        int strI = 0;
        try {
            strI = Integer.parseInt(str);
        } catch (Exception e) {
            log.error("类型转换出错！", e);
            throw new Exception("类型转换出错！");
        }
        strI += num;
        String s = Integer.toString(strI);

        // 换算后的长度小于之前长度，说明字符串是以0开头的，在此补上
        if (s.length() < str.length()) {
            s = leftFill(s, str.length(), '0');
        }

        if (lengthEQ) {
            // 需要判断长度
            if (s.length() == str.length() && startEQ(s, str, 1)) {
                return s;
            } else {
                throw new Exception("字符串长度发生变化，不能返回正确数值");
            }
        } else {
            // 无需判断长度，直接返回
            return s;
        }
    }

    /**
     * 比较版本号的大小,前者大则返回一个正数,后者大返回一个负数,相等则返回0 原文龙
     * 
     * @param version1
     * @param version2
     * @return
     * @throws Exception
     */
    public static int compareVersion(String version1, String version2) throws Exception {
        if (version1 == null || version2 == null) {
            throw new Exception("compareVersion error:illegal params");
        }
        String[] versionArray1 = version1.split("\\.");// 注意此处为正则匹配，不能用.；
        String[] versionArray2 = version2.split("\\.");
        int idx = 0;
        int minLength = Math.min(versionArray1.length, versionArray2.length);// 取最小长度值
        int diff = 0;
        while (idx < minLength && (diff = versionArray1[idx].length() - versionArray2[idx].length()) == 0// 先比较长度
                && (diff = versionArray1[idx].compareTo(versionArray2[idx])) == 0) {// 再比较字符
            ++idx;
        }
        // 如果已经分出大小，则直接返回，如果未分出大小，则再比较位数，有子版本的为大；
        diff = (diff != 0) ? diff : versionArray1.length - versionArray2.length;
        return diff;
    }

    /**
     * 把字符串数组转换成字符串
     * 
     * @param params
     * @return
     */
    public static String getParam(String[] params) {
        StringBuffer param = new StringBuffer();
        if (params != null) {
            for (int i = 0; i < params.length; i++) {
                param.append(params[i]);
                param.append(",");
            }
        }
        return param.toString();
    }

    /**
     * 生成订单号,规则:yyyyMMdd+1位随机数+id
     * 
     * @param id
     *            表主键
     * @return
     */
    public static String getOrderNo(Object id) {

        String orderNo = "";
        // 随机数
        SimpleDateFormat sdf = new SimpleDateFormat("yyMMdd");
        String nowdate = sdf.format(new Date());
        Double dRandom = new Double(10 * Math.random());
        Integer iRandom = new Integer(dRandom.intValue());
        // String sRandom = String.format("%01d", iRandom);
        // 随机字母
        // String chars = "abcdefghijklmnopqrstuvwxyz";
        // char c = (char) (int) (Math.random() * 26 + 97);
        // 合并
        orderNo = nowdate + String.valueOf(iRandom) + String.valueOf(id);
        return orderNo;
    }

    // 将字符串数组转换成字符串
    public String array2String(String[] str) {
        if (str.length > 0) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < str.length; i++) {
                sb.append(str[i] + ",");
            }
            return sb.subSequence(0, sb.length() - 1).toString();
        } else {
            return "";
        }
    }

    /**
     * null转换为""
     */
    public static String str(String str) {
        return str == null ? "" : str;
    }

    public static void main(String[] args) throws Exception {
        // 比较版本号的大小,前者大则返回一个正数,后者大返回一个负数,相等则返回0 原文龙
        Integer i = StringUtil.compareVersion("1.1.54", "1.2.1");
        // System.out.println("i:" + i);
    }
}
